¿Es necesario que uses ese estilo?

No entiendo qué quieres hacer pero si es que unas celdas queden con cierto dato, crea una celda especial que contenga ese dato y a las que quieras que tengan ese dato ponles =(coordenadas de la celda), presiona F4 y copia eso a todas las celdas que quieras.

El programa genera dibujos al azar y cada uno debe tener cierta cantidad de colores, ejemplo 3:

El verde no es parte de los dibujos, es para separarlos.

Básicamente lo he logrado así (este código lo tiene un objeto que es agregado repetidamente en ciertas posiciones como se ve en la imagen, cada cuadrado separado con verde sería un objeto; cuadraditos es lo que tiene ese objeto, no es lo mismo):

// Agregar, distribuir cuadraditos y asignarles un color,
// pero la cantidad de diferentes colores debe ser...
// la indicada por _level0.ColoresRequeridos,
// así que se guardan en una lista y...
// se reasignarán si son menos de lo requerido.
CuadraditosColocados = 0;
Columna = 0;
Fila = 0;
Colores = 0;
trace ("Asignando colores para un nuevo dibujo");
do {
	CuadraditosColocados = CuadraditosColocados+1;
	attachMovie("mCuadradito", "Cuadradito"+CuadraditosColocados, CuadraditosColocados);
	setProperty ("Cuadradito"+CuadraditosColocados, _x, Columna*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _y, Fila*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _width, _level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _height, _level0.LargoDeCuadraditos);
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditosColocados);
	ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
	// Si el dibujo no tenía los colores necesarios:
	if (Colores < _level0.ColoresRequeridos) {
		trace ("El dibujo probablemente aún no tiene los colores requeridos, tenía: "+Colores);
		trace ("Se colocó el cuadradito: "+CuadraditosColocados);
		trace ("Su color es: "+ColorDeCuadradito.getRGB());
		trace ("Se verá si es del mismo color que otro.");
		VerSiColorExisteEtc();
	}
	Columna = Columna+1;
	if (Columna == _level0.CuadraditosPorFila) {
		Columna = 0;
		Fila = Fila+1;
	}
} while (CuadraditosColocados<_level0.MaxCuadradito);
// Si es necesario, reasignar colores hasta lograr lo requerido:
while (Colores < _level0.ColoresRequeridos) {
	trace ("Se asignó color a todos los cuadraditos pero la cantidad de colores del dibujo es sólo: "+Colores);
	trace ("Se volverán a asignar colores.");
	CuadraditoaRepintar = 0;
	Colores = 0;
	do {
		CuadraditoaRepintar++;
		ColorDeCuadradito = new Color("Cuadradito"+CuadraditoaRepintar);
		ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
		VerSiColorExisteEtc();
	} while (CuadraditoaRepintar<_level0.MaxCuadradito);
}

La función mencionada es:

function VerSiColorExisteEtc () {
	// Esto puede cambiar:
	ColorDistinto = "Sí";
	PunteroDeColores = 0;
	while (PunteroDeColores < Colores) {
		PunteroDeColores++;
		trace ("Comparando con el color guardado en el lugar "+PunteroDeColores+": "+eval("ColorEnLista"+PunteroDeColores));
		if (ColorDeCuadradito.getRGB() == eval("ColorEnLista"+PunteroDeColores)) {
			trace ("Iguales, el color del cuadradito recién agregado ya estaba en la lista.");
			ColorDistinto = "No";
			// Para que no siga mirando la lista:
			PunteroDeColores = Colores;
		}
	}
	// Si el color no está en la lista:
	if (ColorDistinto == "Sí") {
		// Agregarlo:
		Colores++;
		set ("ColorEnLista"+Colores, ColorDeCuadradito.getRGB());
		// Esta función se usa en 2 lados distintos usando variables distintas,
		// por eso hay 2 traces:
		trace ("El cuadradito "+CuadraditosColocados+" fue el 1ero de un color no anotado: "+ColorDeCuadradito.getRGB());
		trace ("El cuadradito "+CuadraditoaRepintar+" fue el 1ero de un color no anotado: "+ColorDeCuadradito.getRGB());
		trace ("La cantidad de colores captada ahora es "+Colores);
	}
}

¿Cómo simplificarían el código, si es posible?

El puro azar quiero que se conserve.

A lo que me refiero es que el código, en caso de que el dibujo generado no tenga la cantidad de colores adecuada, reasigna colores a tooodos los cuadraditos, lo cual es ineficiente.

Una alternativa a esa repetición es algo así:
Pero eso asumo que puede tardar mucho en terminar en dibujos más grandes ¿no? Ahora no estoy muy seguro...

Otra alternativa es que se repinten hasta que haya la cantidad requerida de colores, con eso difícil que se necesiten repintar todos. El problema es que si se inicia a repintar desde el nro 1 se pierde el azar puro, porque empieza a resultar más probable que los 1eros colores sean de un color único. Y si se empieza a modificar desde uno al azar, también, porque resulta más probable que los de color único estén cerca.

Se me ocurre algo así:
Hacer una lista de los colores que faltan
Hacer una lista de los colores que sólo están 1 vez (únicos)
Pero además de que puede ser complicado (y quiero terminar de una puñetera vez con esto), dudo que sea más eficiente, por eso de hacer las listas. Tendría que hacerlas cuando por 1era vez se asignan los colores... Para evitar crear otros loops. Ah, tengo un código similar que puedo adaptar.
En fin, la idea con eso es modificar sólo los cuadraditos necesarios, al azar, en vez de modificarlos todos o de color único (lo cual podría disminuir la cantidad). De este modo no se modifican los de color único. No creo que el azar puro se pierda con esto.

Lo intentaré y si lo termino lo publico (tardaré) ¿qué sugieren sobre todo esto?

Edit: Olvidé que ya en el código hacía una lista xD Más fácil entonces.

Edit2: Me líe intentando hacer el código así que hice un pseudocódigo ¿creen que está bien? Al final me desconcentré:

Hacer lista de colores faltantes y únicos.
Ir asignando colores a los cuadraditos.
	Ver si el color elegido está en la lista de faltantes
	Si está
		Quitarlo de la lista de faltantes y Faltantes--
	sino
		Ver si el color elegido está en la lista de únicos
		Si está
			Quitarlo y Unicos--
Repetir si aún hay faltantes
	Unico = "Sí"
	Repetir
		Elegir un cuadradito al azar
		Ver si su color está en la lista de únicos
		Si no está
			Unico = "No"
	mientras Unico == "Sí"
	Al elegido ponerle un color faltante y Faltante--

El 1er usuario me preguntó si lo usé, prácticamente suponiendo que sí, y el 2ndo y el 3ero asumieron que sí. Quora es muy grande, dudo que hayamos interactuado antes, o yo al menos no los registro.

Sí lo he usado pero en tales casos lo he dicho, por ejemplo luego de responder por mi cuenta en una ocasión dije luego "A ver qué dice GPT" y puse su respuesta, pero repito que esos usuarios y yo difícilmente nos hayamos cruzado antes, estamos hablando del post que puse al inicio de este tema. Además que me vieran usarlo (diciendo que lo uso) no debería llevarles a concluir que lo uso siempre, ni en este caso particular, si por ejemplo Overlord tiene 1 o 2 películas y yo no las mencioné porque no las vi. GPT no hubiera hablado de lo que vió. Además está mi comentario respondiéndole al 1ero que no usé GPT, detallando un poco más mi respuesta y diciendo por qué lo bloqueo, o sea, puede ser que no vieran eso, también, hacen todo mal >_<

No es nuevo, dije que lleva registrado desde hace 1 año, y el tipo sólo tenía 1 respuesta, mira ahora:

Sus 2 preguntas son sobre por qué uso GPT y respondió temas míos pero le borraron las respuestas o las borró él luego, de esas respuestas sólo quedó 1.
Lo que yo me preguntaba es por qué un tipo que estaba como en lo más profundo de una cueva, invisible, aparece para criticarme, no tiene mucha lógica ¿por qué esto le pareció tan importante? Pero creo que ya lo entendí. Tiene publicaciones, hay que tener eso en cuenta (Quora es para preguntar y responder pero también se puede poner información random o respuestas en ciertos "Espacios", similarmente a un foro), pero lo ocurrido puede tener que ver con esta pregunta mía:
"¿No sería bueno que Quora impida responder a los que no han hecho preguntas, especialmente si sus respuestas son sólo una imagen? Muy seguido me responden con una imagen propaganda no relacionada con mi pregunta, bloqueo a uno y aparece otro."
Probablemente el tipo, como no tenía preguntas, se ofendió o por decir "Ah, mira, ahora tengo preguntas", hizo esas 2 que ves en la imagen xD

Y bueno, teorías yo también tenía, como que eran amiguitos del 1ero y salieron de debajo de las piedras a defenderlo, pero aún así me parece absurdo, inmaduro como dijiste.

¿Que si son todos distintos? Claro, es lo más probable.

Esta pregunta no sé cómo interpretarla. Puede que un mismo usuario tenga más de 1 cuenta, por ejemplo.


En fin... también todo esto podría explicar por qué me banearon de ciertos sitios o me cerraban temas en uno xD

Un tipo se puso a responder mis preguntas diciendo que uso GPT, y si ves su perfil se registró en 2023 y sólo tiene 2 respuestas porque le borraron las que me acaba de hacer, además hizo 2 temas preguntando por qué uso GPT, o sea ¿cómo alguien registrado el año pasado lo único que hizo en Quora además de publicar no sé qué cosas, fue preguntar por qué uso GPT y responder mis temas quejándose de que uso GPT?

Hay gente muy estúpida. Y si lees esto (que le di el link) tenelo claro: Las veces que usé GPT lo he dicho. No usé GPT para decir qué animes vi.


Imagina hacer algo para un trabajo o carrera y que el evaluador te descalifique por creer que usaste GPT, me parece preocupante, van a tener que crear unas reglas sobre cómo debe ser escrita tu tarea para que no haya malentendidos, pero los bots serán cada vez mejor imitando ¿qué va a pasar?

Quiero entender qué tiene sentido contar y qué no, en videojuegos, pongo una lista de ejemplo (X puede ser un objeto, enemigo, etc):
Se va poniendo cada vez más confuso, algunas cosas resultado de operaciones matemáticas a partir de cosas anteriores, y algunas cosas parecen tener doble interpretación, por ejemplo:
Distint@s X Contactad@s sólo 1 vez, desde la Izq o Der
Con la , no, sólo hay 1 interpretación: Debe haber sido contactado sólo 1 vez, y esa vez debe haber sido por la izquierda o derecha.
Pero es posible esto: Debe haber sido contactado sólo 1 vez por la izquierda o sólo 1 vez por la derecha, es decir, en el caso anterior si se contactó al objeto más de 1 vez entonces ese objeto no se cuenta, pero en el 2ndo caso si se contactó 1 vez por la izquierda o derecha, se cuenta, aunque por abajo o arriba haya sido contactado muchas veces, incluso puede haber sido contactado por la izquierda o derecha más de 1 vez, basta conque por 1 de esos 2 lados haya sido contactado sólo 1 vez.

En fin, ya que es tan confuso, decidí intentar que cuente cosas un programa, yo sólo le digo los eventos básicos. El orden de los eventos no me importa, excepto respecto a por ejemplo por dónde fue el 1er contacto y el último, o sea, no me importa cual fue el 2ndo, ni el 3ero, etc, no me interesa contar algo como "distintos objetos que al ser contactados por 2nda vez fue desde la izquierda".

En el ejemplo que estoy contando, X es escaleras, el personaje contactó 7 escaleras distintas, lo anoté así:
> 1: I3
> 2: D2
> 3: I
> 4: D, Ar, I2
> 5: Ar, I
> 6: D
> 7: I
Por ejemplo la 4 significa que se contactó 1ero por la derecha, luego por arriba, y al final por la izquierda, indicando que en algún otro momento también se contactó por la izquierda.

Serían 7 arrays.

Según he pensado, la mejor estructura que pueden tener es:
Lugar del 1er contacto, contactos desde la izquierda, derecha, arriba, lugar del útimo contacto
¿Me recomiendan otra manera?

No puse abajo porque el personaje no salta así que no contacta escaleras desde abajo de ellas.

Yo prácticamente no sé usar arrays, hago las cosas con "variables sueltas", pero esta vez decidí intentarlo.

Pondría:
Escalera1 = "I", 3, 0, 0, "I"
Escalera2 = "D", 0, 2, 0, "D"
Escalera3 = "I", 0, 0, 0, "I"
Escalera4 = "D", 2, 1, 1, "I"
Escalera5 = "Ar", 1, 0, 1, "I"
Escalera6 = "D", 0, 1, 0, "D"
Escalera7 = "I", 1, 0, 0, "I"

Si puse mal los datos, mala suerte, luego los reviso mejor. La cuestión es: ¿Puede un array tener texto y números? En Macromedia Flash 5, probaré, sino puedo sustituir I por 0, D por 1 y Ar por 2.

No me interesa mucho por ahora variar esos datos pero la idea es que el programa se base siempre en ellos, entonces si quiero contar Distintas contactadas 1ero desde la Izquierda (ah, lo de distintas es redundante a veces, olvidé eso, pero como me ayuda a no confundirme lo dejé), debo poner algo como:
¿no? ¿pero cómo es la condición de ese if específicamente? No sé mucho cómo hacer referencia a las partes de un array y menos si tengo que usar eval.

Esto también lo voy a dar por solucionado, me pareció que debía contar otras cosas, y decidí contarlas de a 1, es decir, contar distintos eventos en distintos momentos del programa, no todos los eventos a la vez, al menos por ahora. Sería largo explicar sobre eso así que termino acá.

Ya logré esto.

// Este programa produce números cada vez más largos,
// intercalándolos según el tipo,
// entre más decimales 1ero,
// y secundariamente los negativos 1ero.
// 
// El 0 aquí se refiere a la cantidad de decimales
// (pero los números se guardan como enteros):
LastPositivoDe0 = -1;
// El programa tiene 5 etapas:
// 1: Esta, donde sólo se definen cosas.
// 2: Produce el 0 y números positivos de 0 decimales.
// 3: Negativos y positivos, de 0 decimales.
// 4: Positivos de 1, negativos y positivos de 0.
// 5: Va creando 2 tipos de número.
// Variables como esta determinan cuánto dura cada etapa,
// o cuando se crean listas y sus máximos valores:
MaxPositivoDe0 = 9;
// Esto se repite en el frame 2:
function Etapa2 () {
	// Producir el 0 o un número positivo:
	LastPositivoDe0++;
	trace (LastPositivoDe0);
	if (LastPositivoDe0 == MaxPositivoDe0) {
		// No hay más números de largo 1,
		// crear lista de negativos:
		LastNegativoDe0 = 0;
		// Indicar nuevos máximos:
		MaxPositivoDe0 = 99;
		MaxNegativoDe0 = -9;
		// Avanzar etapa:
		gotoAndStop (3);
	}
}
// Esto se repite en el frame 3:
function Etapa3 () {
	// ¿Se puede producir un número negativo de largo 2?
	if (LastNegativoDe0>MaxNegativoDe0) {
		// Sí, producirlo:
		LastNegativoDe0--;
		trace (LastNegativoDe0);
	}
	// Positivo:
	LastPositivoDe0++;
	trace (LastPositivoDe0);
	if (LastPositivoDe0 == MaxPositivoDe0) {
		// No hay más números de largo 2.
		// crear lista de positivos de 1 decimal:
		LastPositivoDe1 = 0;
		// Indicar nuevos máximos:
		MaxPositivoDe0 = 999;
		MaxNegativoDe0 = -99;
		// Recuérdese que las listas de decimales...
		// son guardadas como enteros.
		MaxPositivoDe1 = 99;
		// Avanzar etapa:
		gotoAndStop (4);
	}
}
// Esto se repite en el frame 4:
function Etapa4 () {
	// ¿Se pueda producir un número positivo de 1 decimal y largo 3?
	if (LastPositivoDe1<MaxPositivoDe1) {
		// Sí, producirlo:
		LastPositivoDe1++;
		// ¿Termina en 0?:
		Textualizado = String(LastPositivoDe1);
		LastChar = Textualizado.charat(Textualizado.length-1);
		if (LastChar == 0) {
			// Sí, ergo al convertirlo a decimales...
			// no tendrá largo 3, arreglarlo:
			LastPositivoDe1++;
		}
		Decimaleado = LastPositivoDe1/10;
		trace (Decimaleado);
	}
	// ¿Se puede producir un número negativo de largo 3?
	if (LastNegativoDe0>MaxNegativoDe0) {
		// Sí, producirlo:
		LastNegativoDe0--;
		trace (LastNegativoDe0);
	}
	// Positivo:
	LastPositivoDe0++;
	trace (LastPositivoDe0);
	if (LastPositivoDe0 == MaxPositivoDe0) {
		// No hay más números de largo 3,
		// crear nuevas listas:
		LastPositivoDe2 = 0;
		LastNegativoDe1 = 0;
		// Indicar nuevos máximos:
		MaxPositivoDe0 = 9999;
		MaxNegativoDe0 = -999;
		MaxPositivoDe1 = 999;
		MaxNegativoDe1 = -99;
		MaxPositivoDe2 = 999;
		// Para la siguiente etapa:
		MaxDecimales = 2;
		Decimales = 2;
		trace ("Inicia la 5");
		gotoAndStop (5);
	}
}
// Esto se repite en el frame 5:
function Etapa5 () {
	// ¿Se puede producir un número positivo de X decimales y largo Y?
	// X = Decimales.
	Resumen = "LastPositivoDe"+Decimales;
	// trace("Resumen: "+Resumen);
	Evalued = eval(Resumen);
	// trace("Evalued: "+Evalued);
	if (Evalued<eval("MaxPositivoDe"+Decimales)) {
		// Sí, producirlo:
		Evalued++;
		// ¿Termina en 0?:
		Textualizado = String(Evalued);
		LastChar = Textualizado.charat(Textualizado.length-1);
		if (LastChar == 0) {
			// Sí, ergo al convertirlo a decimales...
			// no será del largo requerido, arreglarlo:
			Evalued++;
		}
		Decimaleado = Evalued/Math.pow(10, Decimales);
		trace (Decimaleado);
		// Guardarlo en la lista:
		set (Resumen, Evalued);
	}
	do {
		// Repetir mientras Decimales > 0:
		Decimales--;
		// ¿Se puede producir un número negativo de X decimales y largo Y?
		Resumen = "LastNegativoDe"+Decimales;
		// trace("Resumen: "+Resumen);
		Evalued = eval(Resumen);
		// trace("Evalued: "+Evalued);
		if (Evalued>eval("MaxNegativoDe"+Decimales)) {
			// Sí, producirlo:
			Evalued--;
			if (Decimales>0) {
				// ¿Termina en 0?:
				Textualizado = String(Evalued);
				LastChar = Textualizado.charat(Textualizado.length-1);
				if (LastChar == 0) {
					// Sí, ergo al convertirlo a decimales...
					// no será de largo Y, arreglarlo:
					Evalued--;
				}
			}
			Decimaleado = Evalued/Math.pow(10, Decimales);
			trace (Decimaleado);
			// Guardarlo en la lista:
			set (Resumen, Evalued);
		}
		// ¿Se puede producir un número positivo de X decimales y largo Y?
		// X = Decimales.
		Resumen = "LastPositivoDe"+Decimales;
		// trace("Resumen: "+Resumen);
		Evalued = eval(Resumen);
		// trace("Evalued: "+Evalued);
		if (Evalued<eval("MaxPositivoDe"+Decimales)) {
			// Sí, producirlo:
			Evalued++;
			if (Decimales>0) {
				// ¿Termina en 0?:
				Textualizado = String(Evalued);
				LastChar = Textualizado.charat(Textualizado.length-1);
				if (LastChar == 0) {
					// Sí, ergo al convertirlo a decimales...
					// no tendrá largo Y, arreglarlo:
					Evalued++;
				}
			}
			Decimaleado = Evalued/Math.pow(10, Decimales);
			trace (Decimaleado);
			// Guardarlo en la lista:
			set (Resumen, Evalued);
		}
		if (LastPositivoDe0 == MaxPositivoDe0) {
			// INDICAR SI CONTINÚA O PARA:
			// No hay más números de largo Y.
			// crear listas para números más largos:
			MaxDecimales++;
			set ("LastPositivoDe"+MaxDecimales, 0);
			set ("LastNegativoDe"+MaxDecimales, 0);
			// Indicar nuevos máximos:
			MaxPositivoDe0 = Math.pow(10, Decimales+1)-1;
			MaxNegativoDe0 = Math.pow(10, Decimales)*-1+1;
			Decimales = 0;
			Maximo1 = Math.pow(10, Decimales)-1;
			Maximo2 = Math.pow(10, Decimales-1)*-1+1;
			do {
				Decimales++;
				set ("MaxPositivoDe"+Decimales, Maximo1);
				set ("MaxNegativoDe"+Decimales, Maximo2);
			} while (Decimales<MaxDecimales);
		}
	} while (Decimales>0);
	Decimales = MaxDecimales;
}

Al menos hasta donde probé, ese último if no llegó a ejecutarse.

He aquí el resultado a partir de la etapa 5:
0.01
-0.1
10.1
-100
1000
0.02
-0.2
10.2
-101
1001
0.03
-0.3
10.3
-102
1002
Y sigue.

Los errores que recuerdo eran:
- Había puesto "de" en vez de "De" en una parte.
- Modificaba Resumen, está bien, pero lo que necesitaba modificar en ese momento era Evalued.
- No ponía que Decimales vuelva a ser MaxDecimales.

No sé simplificar el programa, que sean menos etapas, y no sé si conviene.

Es probable que requiera una etapa 6 o algún límite para el largo de los números que produce.

También es probable que la parte de "Indicar nuevos máximos" en la etapa 5 esté mal, lo voy a consultar, pero bueno, ya está.

Interesante. Yo lo que hice fue pedirle que responda como si fuese un humano a una pregunta, pero se notó que era... él. Quizá debí decirle que responda de modo que parezca un humano, que intente hacerme creer que es humano, pero me dio miedito, "Ten cuidado con lo que pides".

En eso somos parecidos. Yo tengo problemas con los puntos y comas a veces, como la idea no termina no pongo punto y puede quedar una oración muy larga.

Pero a ver, a dónde estamos llegando, que una persona crea que porque alguien escribió pocas cosas en distintos párrafos y separando con guiones lo escribió gpt  Esa forma de escribir existe desde hace mucho.

No sé si son casos tan parecidos xD

Tal vez hice mal en bloquear al tipo, pero digamos tuve la amabilidad de responderle y se pone a hacer acusaciones, no me parece respetable, yo no me voy a poner a demostrar que vi esas series, luego que soy humano y todo lo que se le antoje poner en duda. El agregado "verdad" es un indicativo de que estaba bastante convencido, pero hay preguntas que no corresponde hacer, el hecho de hacerlas es una falta de respeto.

Por otro lado, no leí el mensaje que dices que te borraron pero si bien se agradece y no le veo el problema, el tema no era sobre atentados y ya se sabe cómo funcionan las cosas aquí, para bien o para mal. Es una situación más compleja la que mencionas... Y no quiero hablar mucho de eso imaginas por qué.

Por cierto, luego otro me dijo "por qué usaste gpt? te voy a denunciar" y cuando terminé de responderle ya no estaba su comentario, se lo borraron o lo borró. Una pena porque a este sí le hice bastantes preguntas considerando posibles explicaciones sobre por qué creyó que lo mío fue usando gpt, no creí que fuese un troll (miré sus actividades) y quise entender qué tiene en la cabeza.

Suerte.