Al decir 'duran demasiado', no tengo claro si tratas de decir que la ejecución del interior 'hace demasiadas cosas' o que la condición (en el ejemplo un contador), es elevado....
Verás, si estás operando con cada día del año, que son 365, pués es correcto que el bucle deba tener 365 iteraciones... que te guste o no, no tiene sentido. El cóoooodigo que debe hacerse es justo el preciso que resuelva el problema que se trata de solucionar, no otro distinto que  te resulte 'más bonito'... para cosas bonitas, está el arte (pintura, escultura, etc...). La programación es funcional, es lo que se le exige.

pero ahí, simplemente estás haciendo 2 incrementos seguidos, para eso proporcionas al contador que sume de dos en dos y ya.
Claro que  quizás sea solo a modo d eejemplo del cuerpo de un bucle, en ese caso, repetir 2 veces el cuerpo completo de un bucle uno tras otro, es hacer redundancia del código para nada.
Los bucles son hoy día muy efectivos, pués el procesador cuenta con registros de índice y comprobaciones que lo hacen muy eficiente.
Desde luego un salto incondicional tras una comparación más o menos compleja (que hacen las veces de condiciones), puede ser ligeramente más rápido, pero oscurece el código, especialmente cuando el código ha de tener muchas líneas de código... y con muchas no me refiero a unas cientas o pocos miles (que también notarán esa afección).

Los bucles forman la primera salida hacia la programación estrucutrada... quien a día de hoy no los use (porque prefiera usar 'goto's), como programador no puede tener mucho futuro, porque allí donde vaya, nadie va a entender su código sin dedicarle unos meses y ninguna empresa estará dispuesto a que sus trabajadores pierdan tiempo tan estúpidamente solo por ahorrar 2 instrucciones con cada iteración de un bucle. A menudo optimizando el código superas en mucho la eficiencia como para preocuparte de una cosa tan insignificante. ...nota que a día de hoy, los procesadores operan en el rango de 1-5 mil millones de instrucciones por segundo, y entiende por tanto lo estupido de tratar de ahorrar 2 instrucciones en un bucle de 100, 1000 o 1.000.000 de iteraciones, cuando revisando el código seguramente se pueda mejorar en muchas partes quizás hasta un 10% más eficiente, a menudo incluso no es extraño un 1000%, especialmente en casos de usar lenguajes inadecuados.

Por otro lado, tu gran problema (creo que ya te lo he dicho más de una vez, aunque quizás con otras palabras), es que estás muy limitado porque usas un lenguaje muy limitado.
Nada peor para un programador que ajustarse a la medida de un lenguaje, porque implica que sus luces y sus sombras no vendrán marcadas por su intelecto, sino directamente limitadas por el lenguaje en el que 'se autoajusta'.
Un lenguaje de programación, debe servir para ampliarte horizontes, no para limitártelos. Cuando un lenguaje te limita, es el momento adecuado para abandonarlo y saltar a otro más 'evolucionado', menos limitado, salvo que al momento presente no exista ninguno mejor al caso...

Hice esto:

   actions for fotograma 1
      // Este programa produce 1ero un número de longitud 1: 0.
      // Luego otro de long 1: 1. Y otro de long 2: 10.
      // Luego otro de 1: 2. Otro de 2: 11. Y uno de 3: 100.
      // Y así. Es como si produjera cada vez más listas,
      // que tienen números más largos que las anteriores,
      // pero sólo se guarda el último valor de cada una.
      // Los valores de la lista 1 tendrán longitud 1. Los de la 2, 2.
      // Y así. Cuando ya no es posible producir uno de una longitud,
      // no se producen más de esa.
      SolucionesHalladas = 0;
      MinLongitudDeLosN = 1;
      MaxLongitudDeLosN = 1;
      ValorDelUltimoNDeLaLista1 = -1;
      LongitudDelNaModificar = MinLongitudDeLosN;
      function ProcesoaRepetir () {
         NombreDelNaModificar = "ValorDelUltimoNDeLaLista"+LongitudDelNaModificar;
         // Obtener lo que sería el nuevo valor de la lista indicada por LongitudDelNaModificar:
         N = eval(NombreDelNaModificar)+1;
         // ¿El nuevo N ya fue producido por otra lista?
         // O: ¿Tiene N más longitud que los Ns de su propia lista?
         if (String(N).length>LongitudDelNaModificar) {
            // Sí, no producir más Ns de esa lista:
            MinLongitudDeLosN = MinLongitudDeLosN+1;
            // La función se reaplicará pero para producir un N de una longitud mayor:
            LongitudDelNaModificar = MinLongitudDeLosN;
            if (Fram == 3) {
               gotoAndPlay (2);
            }
         } else {
            // Guardar el valor en la lista correspondiente:
            set (NombreDelNaModificar, N);
            // Obtener característica usando N:
            CaracteristicaDeN = String(N).charat(N);
            trace (N+" resulta "+Caracteristica);
            // Si se obtiene una característica deseada, informar,
            // guardarla y incrementar las soluciones halladas.
            if (CaracteristicaDeN == 0) {
               if (Solfor0 == undefined) {
                  Solfor0 = N;
                  trace ("para que la característica sea 0 usar N: "+N);
                  SolucionesHalladas = SolucionesHalladas+1;
               }
            } else if (CaracteristicaDeN == -9) {
               if (Solfor9 == undefined) {
                  Solfor9 = N;
                  trace ("para que la característica sea -9 usar N: "+N);
                  SolucionesHalladas = SolucionesHalladas+1;
               }
            } else if (CaracteristicaDeN == 4.5) {
               if (Solfor4 == undefined) {
                  Solfor4 = N;
                  trace ("para que la característica sea 4.5 usar N: "+N);
                  SolucionesHalladas = SolucionesHalladas+1;
               }
            } else if (CaracteristicaDeN == -7.2) {
               if (Solfor7 == undefined) {
                  Solfor7 = N;
                  trace ("para que la característica sea -7.2 usar N: "+N);
                  SolucionesHalladas = SolucionesHalladas+1;
               }
            }
            gotoAndPlay (4);
         }
      }
   actions for fotograma 2
      Fram = 2;
      ProcesoaRepetir();
   actions for fotograma 3
      Fram = 3;
      ProcesoaRepetir();
   actions for fotograma 4
      // ¿El último valor producido es de la lista de los más largos?
      if (LongitudDelNaModificar<MaxLongitudDeLosN) {
         // No, producir uno de una lista de más largos:
         LongitudDelNaModificar = LongitudDelNaModificar+1;
      } else {
         // Sí, se creará un valor para una nueva lista, de valores más largos:
         // La siguiente ecuación no funciona cuando MaxLongitudDeLosN es 1, por eso hay un if y else:
         if (MaxLongitudDeLosN>1) {
            set ("ValorDelUltimoNDeLaLista"+(MaxLongitudDeLosN+1), eval("ValorDelUltimoNDeLaLista"+MaxLongitudDeLosN)*10-1);
         } else {
            set ("ValorDelUltimoNDeLaLista"+(MaxLongitudDeLosN+1), 9);
         }
         MaxLongitudDeLosN = MaxLongitudDeLosN+1;
         // Producir un valor de la mínima longitud actual:
         LongitudDelNaModificar = MinLongitudDeLosN;
      }
      gotoAndPlay (2);
 

Funciona mucho más rápido pero no lo puedo parar (no sé por qué) y en cierto punto me aparece el mensaje:


Intentaré entender por qué no lo puedo parar y mejorarlo pero si sigo así para cuestiones como esta puede que pida que me recomienden un programa/lenguaje. Por ahora no.