Positivos, negativos y decimales. El - y el . cuentan en lo largo.

Al principio debería mostrar 0, 1, 2, y así hasta 9. Números de largo 1.

Luego -1, 10, -2, 11... y así, son de largo 2 y se van intercalando, me refiero a que no se muestra 1ero todos los negativos de largo 2 y luego todos los positivos de largo 2, sino que muestra un negativo de largo 2, luego un positivo de largo 2, y se repite eso hasta que no hayan de largo 2.

Luego 0.1, -10, 100, 0.2, -11, 101... la idea es la misma.

Luego 0.01, -0.1, 10.1, -100, 1000... creo que son 5 tipos, la idea es la misma. Los que tienen más decimales van 1ero, si 2 tipos tienen igual cantidad va el negativo 1ero. Probablemente se me está escapando algo pero más o menos es eso.

Lo que se me ocurre es algo como:
Hasta ahí llegué por ahora porque al número habría que sumarle en un caso 1, en otro caso 0.1, o 0.01, y así, o restarle, así que el modificador es variable, no me había dado cuenta. Ahora bien, ese código tiene el problema de que estaría haciendo sumas a ver si el número del tipo de turno puede mostrarse, lo cual es poco eficiente. En el mismo loop también se chequearía para el negativo. La cantidad de decimales iría aumentando, se resetearía al llegar al máximo y en ese punto aumentaría el largo.

Lo seguiré pensando pero si se les ocurre alguna solución o sugerencia díganme cual.

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á.