Autor Tema: Distribuir cosas en una tabla ¿división básica?

0 Usuarios y 1 Visitante están viendo este tema.

23 Mayo, 2024, 07:31 am
Leído 890 veces

Tachikomaia

  • $$\Large \color{#5b61b3}\pi\,\pi\,\pi\,\pi\,\pi$$
  • Mensajes: 1,297
  • País: uy
  • Karma: +0/-0
  • Sexo: Masculino
Mi duda es más compleja que esta pero esta es análoga creo: Tenemos una tabla de L*L casilleros, es decir siempre es un cuadrado, y queremos pintar cada casillero de un color, usando C colores.

Si por ejemplo L=3 y C=2 (Blanco y Negro) entonces quiero que quede así:
BBB
BBN
NNN
Es decir se hace 9/2, da 4 y sobra 1, ese sobrante debe ir para el 1er color. Si sobraran 2 y fuesen 3 colores, entonces esos 2 serían para los 1eros 2.

Si L=3 y C=3 (B, N y Gris) entonces es fácil:
BBB
NNN
GGG

Si L=3 y C=10 (1, 2, 3... 9, A) entonces también es fácil:
123
456
789
En este caso el color 10 o A no se aplica.

No sé plantear bien mi duda pero, si los casilleros están nombrados como acabo de poner y C es menor que L*L, como puse en el 1er ejemplo ¿cómo asigno los colores?

L=3, C=5 (Azul, Blanco, Celeste, Dorado, Esmeralda).
9/5=1 sobran 4
AAB
BCC
DDE
ColorDeCasillero1 = A
ColorDeCasillero2 = A
ColorDeCasillero3 = B
ColorDeCasillero4 = B
ColorDeCasillero5 = C
ColorDeCasillero6 = C
ColorDeCasillero7 = D
ColorDeCasillero8 = D
ColorDeCasillero9 = E
A esas letras podemos cambiarlas por números:
A -> 1
B -> 2
etc
¿Cual es la fórmula tal que
si casillero=1 entonces color=1
si 2 entonces 1
si 3 entonces 2
etc?

Cuando se debe asignar un color ¿cómo se debe hacer? Veo el casillero 1 ¿y? ¿qué hago con ese número 1, o el que sea, cómo a partir de un número de casillero y teniendo en cuenta L y C asigno los colores?

23 Mayo, 2024, 07:58 am
Respuesta #1

feriva

  • $$\Large \color{#a53f54}\pi\,\pi\,\pi\,\pi\,\pi\,\pi\,\pi$$
  • Mensajes: 12,032
  • País: es
  • Karma: +1/-0
  • Sexo: Masculino

Entiendo que a las filas, en ciertos casos, les asignas un solo color de arriba a abajo y de forma que todas las filas tienen un color distinto; son los casos en los que L=C.

También entiendo que cosideras un orden previo en los colores. Cuando hablas de que le resto 1 debe ir para el primer color, creo que te refieres a que consideras que el blanco es el primero previamente: blanco, negro y gris. Entonces, según ese orden, a la primera fila le corresponde el color blanco.

En caso de que L sea distinto de C, y C menor que L, entiendo que, una vez que se acaba de asignar la cantidad del resto a los primeros colores, sigues con los otros.

Eso es lo que entiendo, no sé si bien. ¿Hay alguna cosa más a tener en cuenta?

Saludos.

23 Mayo, 2024, 11:13 am
Respuesta #2

Luis Fuentes

  • el_manco
  • Administrador
  • Mensajes: 58,905
  • País: es
  • Karma: +0/-0
Hola

 Para un tablero \( L\times L \) y \( c \) colores llama:

 N=L^2
 a=floor(N/c)  (parte entera de N/c)
 r=mod(N,c) (resto de dividir N entre c)

 Entonces el número de color que tienes que poner en la fija i, columna j, es:

 - Si p<=r*(a+1), floor((p-1)/(a+1)+1
 - Si p>r*(a+1), r+1+floor((p-r(a+1)-1)/a)

 donde p=(i-1)*L+j

 Aquí lo tienes implementado en GeoGebra:


Saludos.

26 Mayo, 2024, 12:15 pm
Respuesta #3

Tachikomaia

  • $$\Large \color{#5b61b3}\pi\,\pi\,\pi\,\pi\,\pi$$
  • Mensajes: 1,297
  • País: uy
  • Karma: +0/-0
  • Sexo: Masculino
feriva:
Luis lo hizo, las respuestas están ahí.

Luis Fuentes:
¡Qué bárbaro, con programa hecho!  :aplauso:

Lo preciso en base al número de casillero, no de fila y columna ¿podrías o alguien adaptarlo a eso?

Aquí lo convertí a mi estilo aunque me falta probarlo y definir P mejor:
Código: [Seleccionar]
Casilleros = CasillerosPorFila^2;
MínNrodeCasIgualPintados = Math.floor(Casilleros/Colores);
Resto = Casilleros%Colores;
Fila = 0;
Repetir:
  Fila++;
  Columna = 0;
  Repetir:
    Columna++;
    P = (Fila-1)*CasillerosPorFila+Columna;
    Si P <= Resto*(MínNrodeCasIgualPintados+1):
      Colorde() = Math.floor((P-1)/(MínNrodeCasIgualPintados+1)+1;
    sino
      Colorde() = Resto+1+Math.floor((P-Resto*(MínNrodeCasIgualPintados+1)-1)/MínNrodeCasIgualPintados);
  mientras Columna < CasillerosPorFila
mientras Fila < CasillerosPorFila

Lo que pasa que tengo objetos en la pantalla, son Dibujo1, Dibujo2, etc, y yo estoy asignando a cada uno un número como has hecho, hago algo así:
Dibujo = 0;
Repetir:
  Dibujo++;
  Asignar número a "Dibujo"+Dibujo.
mientras Dibujo<Dibujos
...
Si tuviese que averiguar el valor de la variable Dibujo en base a su f¡la y columna... Se puede, pero no parece buena idea ¿no?

26 Mayo, 2024, 01:36 pm
Respuesta #4

Richard R Richard

  • Ingeniero Industrial
  • $$\Large \color{#9c57a6}\pi\,\pi\,\pi\,\pi\,\pi\,\pi$$
  • Mensajes: 4,041
  • País: ar
  • Karma: +2/-0
  • Sexo: Masculino
  • Dentro de la ciencia todo,fuera de la ciencia nada
Lo que te falta para saber el número de casillero $$n$$ en  función del número de fila $$i$$ y de columna $$j$$ es hacer $$n=(i-1)*L+j$$ si $$L$$ es la cantidad de casilleros por lado y cuenta avanzando columna por columna dentro de una misma fila.
Saludos  \(\mathbb {R}^3\)

26 Mayo, 2024, 02:10 pm
Respuesta #5

Luis Fuentes

  • el_manco
  • Administrador
  • Mensajes: 58,905
  • País: es
  • Karma: +0/-0
Hola

Lo que te falta para saber el número de casillero $$n$$ en  función del número de fila $$i$$ y de columna $$j$$ es hacer $$n=(i-1)*L+j$$ si $$L$$ es la cantidad de casilleros por lado y cuenta avanzando columna por columna dentro de una misma fila.

Si, eso es esto:


 Para un tablero \( L\times L \) y \( c \) colores llama:

 N=L^2
 a=floor(N/c)  (parte entera de N/c)
 r=mod(N,c) (resto de dividir N entre c)

 Entonces el número de color que tienes que poner en la fija i, columna j, es:

 - Si p<=r*(a+1), floor((p-1)/(a+1)+1
 - Si p>r*(a+1), r+1+floor((p-r(a+1)-1)/a)

 donde p=(i-1)*L+j

Citar
Lo preciso en base al número de casillero, no de fila y columna ¿podrías o alguien adaptarlo a eso?

El número de casillero es precisamente \( p \).

Saludos.

02 Junio, 2024, 10:09 pm
Respuesta #6

Tachikomaia

  • $$\Large \color{#5b61b3}\pi\,\pi\,\pi\,\pi\,\pi$$
  • Mensajes: 1,297
  • País: uy
  • Karma: +0/-0
  • Sexo: Masculino
Tengo esto, miren especialmente donde dice NUMEROMISTERIOSO casi al final:
Código: [Seleccionar]
on (release) {
// Los dibujos serán como el de encima de este botón
// y mutarán:
Dibujo = 0;
// Repetir para el dibujo 1, 2, etc:
do {
Dibujo++;
// El dibujo a copiar no necesita ser modificado:
if (Dibujo != _parent.ID) {
Cuadradito = 0;
// Repetir hasta que todo cuadradito se haya copiado,
// por ahora no hay mutación:
do {
Cuadradito++;
ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
} while (Cuadradito<_level0.MaxCuadradito);
// De cada dibujo copia, variar cuadraditos al azar,
// de 1 hasta CuadraditosPorFila,
// aumentando por dibujo hacia derecha y abajo:
// Repetir hasta que se haya variado esa cantidad...
// de cuadraditos:
CuadraditosModificados = 0;
do {
CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+(random(_level0.MaxCuadradito)+1);
ColoraSustituirse = new Color(CuadraditoaCambiar);
// A esto lo convierto a String porque...
// lo debo comparar con un string y es más fácil así.
SavedeColoraSustituirse = ""+(ColoraSustituirse.getRGB());
trace ("SavedeColoraSustituirse: "+SavedeColoraSustituirse);
// Repetir mientras el color no cambie:
do {
NuevoColor = _parent.PosiblesColores[random(_parent.PosiblesColores.length)];
} while (NuevoColor == SavedeColoraSustituirse);
ColoraSustituirse.setRGB(NuevoColor);
trace ("NuevoColor: "+NuevoColor);
CuadraditosModificados++;
} while (CuadraditosModificados<NUMEROMISTERIOSO);
}
} while (Dibujo<_level0.MaxCuadro);
}

Voy a pensar qué debo poner, en base a lo que me dijeron. En otro lado puse:
DistintasMutaciones = Math.floor(MaxCuadro/CuadraditosPorFila);
Resto = MaxCuadro%CuadraditosPorFila;

Es esto:
 a=floor(N/c)  (parte entera de N/c)
 r=mod(N,c) (resto de dividir N entre c)
N ya lo tenía.

Luego, parece que no preciso filas ni columnas, como al final lo pusiste pensé que sí.

No me queda claro si esto
Si p<=r*(a+1), floor((p-1)/(a+1)+1
es así:
floor((p-1)/(a+1)+1)
o así:
floor((p-1)/(a+1))+1
Probaré.

Me quedó así:
Código: [Seleccionar]
on (release) {
// Los dibujos serán como el de encima de este botón
// y mutarán:
Dibujo = 0;
// Repetir para el dibujo 1, 2, etc:
do {
Dibujo++;
// El dibujo a copiar no necesita ser modificado:
if (Dibujo != _parent.ID) {
Cuadradito = 0;
// Repetir hasta que todo cuadradito se haya copiado,
// por ahora no hay mutación:
do {
Cuadradito++;
ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
} while (Cuadradito<_level0.MaxCuadradito);
// De cada dibujo copia, variar cuadraditos al azar,
// de 1 hasta CuadraditosPorFila,
// aumentando por dibujo hacia derecha y abajo:
// Repetir hasta que se haya variado esa cantidad...
// de cuadraditos:
CuadraditosModificados = 0;
if (Dibujo <= _level0.Resto*(_level0.DistintasMutaciones+1)) {
ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
} else {
ModificacionesRequeridas = _level0.Resto+1+Math.floor((Dibujo-_level0.Resto(_level0.DistintasMutaciones+1)-1)/_level0.DistintasMutaciones);
}
do {
CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+(random(_level0.MaxCuadradito)+1);
ColoraSustituirse = new Color(CuadraditoaCambiar);
// A esto lo convierto a String porque...
// lo debo comparar con un string y es más fácil así.
SavedeColoraSustituirse = ""+(ColoraSustituirse.getRGB());
trace ("SavedeColoraSustituirse: "+SavedeColoraSustituirse);
// Repetir mientras el color no cambie:
do {
NuevoColor = _parent.PosiblesColores[random(_parent.PosiblesColores.length)];
} while (NuevoColor == SavedeColoraSustituirse);
ColoraSustituirse.setRGB(NuevoColor);
trace ("NuevoColor: "+NuevoColor);
CuadraditosModificados++;
} while (CuadraditosModificados<ModificacionesRequeridas);
}
} while (Dibujo<_level0.MaxCuadro);
}

Puede que esté haciendo mal algo:

Explico. Habiendo cliqueado el dibujo superior izquierdo, la idea es que los siguientes muten cada vez más como expliqué al inicio hablando de colores. Aquí no es sobre colores, es sobre diferencias con respecto a ese dibujo, puede ser en colores o no.
En la 1er fila, todos variaron 1 cuadradito.
En la 2nda algunos variaron 1 y otros 3. se ronpio elteclad

Conseguí otro, eso último lo escribí con el mouse haciendo copy-paste xD En fin, deberé analizar mi código. También me gustaría saber si esa fórmula puede aplicarse también cuando el número a distribuir es mayor o igual que la cantidad de casilleros.

11 Junio, 2024, 12:40 am
Respuesta #7

Tachikomaia

  • $$\Large \color{#5b61b3}\pi\,\pi\,\pi\,\pi\,\pi$$
  • Mensajes: 1,297
  • País: uy
  • Karma: +0/-0
  • Sexo: Masculino
Algo tengo mal, en un área de 5x5 que debe ser repartida en 4 partes obtengo:
(Nro de casillero, número asignado (que puede entenderse como color)):
2: 1
3: 1
4: 1
5: 1
6: 1
7: 1
8: 3
9: 3
10: 3
11: 3
12: 3
13: 4
14: 4
15: 4
16: 4
17: 4
18: 4
19: 5
20: 5
21: 5
22: 5
23: 5
24: 5
25: 6

Mi código es:
Código: [Seleccionar]
DibujosPorFila = 5;
MaxCuadro = DibujosPorFila*DibujosPorFila;
CuadraditosPorFila = 4;
MaxCuadradito = CuadraditosPorFila*CuadraditosPorFila;
DistintasMutaciones = Math.floor(MaxCuadro/CuadraditosPorFila);
Resto = MaxCuadro%CuadraditosPorFila;
on (release) {
// Los dibujos serán como el de encima de este botón
// y mutarán:
Dibujo = 0;
// Repetir para el dibujo 1, 2, etc:
do {
Dibujo++;
// El dibujo a copiar no necesita ser modificado:
if (Dibujo != _parent.ID) {
Cuadradito = 0;
// Repetir hasta que todo cuadradito se haya copiado,
// por ahora no hay mutación:
do {
Cuadradito++;
ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
} while (Cuadradito<_level0.MaxCuadradito);
// De cada dibujo copia, variar cuadraditos al azar,
// de 1 hasta CuadraditosPorFila,
// aumentando por dibujo hacia derecha y abajo:
// Repetir hasta que se haya variado esa cantidad...
// de cuadraditos:
CuadraditosModificados = 0;
if (Dibujo <= _level0.Resto*(_level0.DistintasMutaciones+1)) {
ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
} else {
ModificacionesRequeridas = _level0.Resto+1+Math.floor((Dibujo-_level0.Resto(_level0.DistintasMutaciones+1)-1)/_level0.DistintasMutaciones);
}
trace(Dibujo+": "+ModificacionesRequeridas);
do {
CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+(random(_level0.MaxCuadradito)+1);
ColoraSustituirse = new Color(CuadraditoaCambiar);
// A esto lo convierto a String porque...
// lo debo comparar con un string y es más fácil así.
SavedeColoraSustituirse = ""+(ColoraSustituirse.getRGB());
// trace ("SavedeColoraSustituirse: "+SavedeColoraSustituirse);
// Repetir mientras el color no cambie:
do {
NuevoColor = _parent.PosiblesColores[random(_parent.PosiblesColores.length)];
} while (NuevoColor == SavedeColoraSustituirse);
ColoraSustituirse.setRGB(NuevoColor);
// trace ("NuevoColor: "+NuevoColor);
CuadraditosModificados++;
} while (CuadraditosModificados<ModificacionesRequeridas);
}
} while (Dibujo<_level0.MaxCuadro);
}

¿Qué tengo mal?
Código: [Seleccionar]
if (Dibujo <= _level0.Resto*(_level0.DistintasMutaciones+1)) {
ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
} else {
ModificacionesRequeridas = _level0.Resto+1+Math.floor((Dibujo-_level0.Resto(_level0.DistintasMutaciones+1)-1)/_level0.DistintasMutaciones);
}

¿Tal vez planteé mal la duda?
Son 25 espacios a repartir entre 4 cosas, debe quedar:
Del 1 al 7: Son de 1.
De 8 a 13: De 2.
De 14 a 19: De 3.
De 20 a 25: De 4.
11111
11222
22233
33334
44444

11 Junio, 2024, 03:27 am
Respuesta #8

Richard R Richard

  • Ingeniero Industrial
  • $$\Large \color{#9c57a6}\pi\,\pi\,\pi\,\pi\,\pi\,\pi$$
  • Mensajes: 4,041
  • País: ar
  • Karma: +2/-0
  • Sexo: Masculino
  • Dentro de la ciencia todo,fuera de la ciencia nada
Mi duda es más compleja que esta pero esta es análoga creo: Tenemos una tabla de L*L casilleros, es decir siempre es un cuadrado, y queremos pintar cada casillero de un color, usando C colores.Si por ejemplo L=3 y C=2 (Blanco y Negro) entonces quiero que quede así:BBBBBNNNNEs decir se hace 9/2, da 4 y sobra 1, ese sobrante debe ir para el 1er color. Si sobraran 2 y fuesen 3 colores, entonces esos 2 serían para los 1eros 2.
Algo tengo mal, en un área de 5x5 que debe ser repartida en 4 partes obtengo:
primero  divide a 5x5=25 por 4   obtienes 6 y te sobra 1 ,como obtienes  cada número en codigo con
Código: [Seleccionar]
y=entero( L^2/C)
z= resto(L^2/C)

como asignas números
define una variable donde asigne el número de color en función de su número dentro del cuadrado

Código: [Seleccionar]
Ncolor(w)haz un codigo en tu idioma
Código: [Seleccionar]
casilla=1
x=1
do while casilla <L^2+1
if x<= z entonces     
   Ncolor(casilla)= x
   casilla=casilla+1
    x=entero((casilla-1)/(y+1))+1
 else
    Ncolor(casilla)= x
   casilla=casilla+1
    x=entero((casilla-1-z*(y+1))/(y))+1+z
end if

loop

 Saludos
 Corregido un gazapo posicionamiento

Saludos  \(\mathbb {R}^3\)

15 Junio, 2024, 09:07 am
Respuesta #9

Tachikomaia

  • $$\Large \color{#5b61b3}\pi\,\pi\,\pi\,\pi\,\pi$$
  • Mensajes: 1,297
  • País: uy
  • Karma: +0/-0
  • Sexo: Masculino
primero  divide a 5x5=25 por 4   obtienes 6 y te sobra 1 ,como obtienes  cada número en codigo con
[/size]
Código: [Seleccionar]
y=entero( L^2/C)
z= resto(L^2/C)
Eso lo tengo bien:
  Variable _level0.DistintasMutaciones = 6
  Variable _level0.Resto = 1

Bueno, pruebo lo que dices pero no tengo mucha idea de qué estás haciendo. En la izquierda está lo que haces y en la derecha lo que tengo por ahora, lo que está en verde en ambos lados es lo mismo con distinto nombre:

El loop no se copió ahí, no sé por qué, pero eso no creo que sea el problema.

Mejor olvida lo de casilleros y colores, son dibujos hechos de cuadraditos de colores, y al cliquear un dibujo quiero que todos los dibujos queden iguales a ese (es decir que los cuadraditos de los dibujos queden iguales a los de ese dibujo), como si fuesen pantallas que ahora deben mostrar todas el mismo canal. PERO, quiero que haya ciertas variaciones, mutaciones, diferencias. Eso son los números que quiero distribuir. Unos dibujos debe tener 1 diferencia, otros 2, y así, como expliqué. No lo había descrito de este modo porque pensé que con los colores sería más fácil de entender. Me equivoqué quizá, si eso está generando malinterpretaciones.

Publico esto por las dudas que se me borre de la PC pero ya pruebo tu código, en un rato cuento cómo me fue.

Listo, hice esto:
Código: [Seleccionar]
on (release) {
// Los dibujos serán como el de encima de este botón
Dibujo = 1;
X = 1;
// Repetir para el dibujo 1, 2, etc:
while (Dibujo < _level0.MaxCuadro+1) {
// Este if es porque el dibujo a copiar no necesita...
// ser modificado, eso sería como sustituirse por él mismo:
if (Dibujo != _parent.ID) {
Cuadradito = 0;
// Repetir hasta que todo cuadradito se haya copiado,
// por ahora no hay mutación:
do {
Cuadradito++;
ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
} while (Cuadradito<_level0.MaxCuadradito);
// Los dibujos mutarán:
// De cada dibujo copia, variar cuadraditos al azar,
// de 1 hasta CuadraditosPorFila,
// aumentando por dibujo hacia derecha y abajo:
ModificacionesRequeridas = X;
trace("Al dibujo "+Dibujo+" se le modificarán "+ModificacionesRequeridas+" cuadraditos.");
// Repetir hasta que se haya variado esa cantidad...
// de cuadraditos:
CuadraditosModificados = 0;
do {
CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+(random(_level0.MaxCuadradito)+1);
ColoraSustituirse = new Color(CuadraditoaCambiar);
// A esto lo convierto a String porque...
// lo debo comparar con un string y es más fácil así.
SavedeColoraSustituirse = ""+(ColoraSustituirse.getRGB());
// trace ("SavedeColoraSustituirse: "+SavedeColoraSustituirse);
// Repetir mientras el color no cambie:
do {
NuevoColor = _parent.PosiblesColores[random(_parent.PosiblesColores.length)];
} while (NuevoColor == SavedeColoraSustituirse);
ColoraSustituirse.setRGB(NuevoColor);
// trace ("NuevoColor: "+NuevoColor);
CuadraditosModificados++;
} while (CuadraditosModificados<ModificacionesRequeridas);
}
Dibujo++;
if (X <= _level0.Resto) {
X = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
} else {
    X = Math.floor((Dibujo-1-_level0.Resto*(_level0.DistintasMutaciones+1))/(_level0.DistintasMutaciones))+1+_level0.Resto
}
}
}

Y al cliquear el 1 me da esto:
Al dibujo 2 se le modificarán 1 cuadraditos.
Al dibujo 3 se le modificarán 1 cuadraditos.
Al dibujo 4 se le modificarán 1 cuadraditos.
Al dibujo 5 se le modificarán 1 cuadraditos.
Al dibujo 6 se le modificarán 1 cuadraditos.
Al dibujo 7 se le modificarán 1 cuadraditos.
Al dibujo 8 se le modificarán 2 cuadraditos.
Al dibujo 9 se le modificarán 2 cuadraditos.
Al dibujo 10 se le modificarán 2 cuadraditos.
Al dibujo 11 se le modificarán 2 cuadraditos.
Al dibujo 12 se le modificarán 2 cuadraditos.
Al dibujo 13 se le modificarán 2 cuadraditos.
Al dibujo 14 se le modificarán 3 cuadraditos.
Al dibujo 15 se le modificarán 3 cuadraditos.
Al dibujo 16 se le modificarán 3 cuadraditos.
Al dibujo 17 se le modificarán 3 cuadraditos.
Al dibujo 18 se le modificarán 3 cuadraditos.
Al dibujo 19 se le modificarán 3 cuadraditos.
Al dibujo 20 se le modificarán 4 cuadraditos.
Al dibujo 21 se le modificarán 4 cuadraditos.
Al dibujo 22 se le modificarán 4 cuadraditos.
Al dibujo 23 se le modificarán 4 cuadraditos.
Al dibujo 24 se le modificarán 4 cuadraditos.
Al dibujo 25 se le modificarán 4 cuadraditos.

Bien, pero estoy muy cansado.

 :aplauso: